package com.lostreseditores.sabersai.presentation.businessDelegate;

import java.util.Date;
import java.util.List;
import java.util.Map;

import com.lostreseditores.sabersai.model.Acceso;
import com.lostreseditores.sabersai.model.Analizaxrespuesta;
import com.lostreseditores.sabersai.model.Asignatura;
import com.lostreseditores.sabersai.model.Asignaturaxcompetencia;
import com.lostreseditores.sabersai.model.Asignaturaxcomponente;
import com.lostreseditores.sabersai.model.Asignaturaxexamen;
import com.lostreseditores.sabersai.model.Bases;
import com.lostreseditores.sabersai.model.Calificacion;
import com.lostreseditores.sabersai.model.Calificacionxestudiante;
import com.lostreseditores.sabersai.model.Calificaperiodo;
import com.lostreseditores.sabersai.model.Claseasignatura;
import com.lostreseditores.sabersai.model.Colegio;
import com.lostreseditores.sabersai.model.Competencia;
import com.lostreseditores.sabersai.model.Componente;
import com.lostreseditores.sabersai.model.Comunidad;
import com.lostreseditores.sabersai.model.Curso;
import com.lostreseditores.sabersai.model.Distribuidor;
import com.lostreseditores.sabersai.model.Estudiante;
import com.lostreseditores.sabersai.model.Examen;
import com.lostreseditores.sabersai.model.Examenxreporte;
import com.lostreseditores.sabersai.model.Genero;
import com.lostreseditores.sabersai.model.Jornada;
import com.lostreseditores.sabersai.model.Logro;
import com.lostreseditores.sabersai.model.Lugar;
import com.lostreseditores.sabersai.model.Menu;
import com.lostreseditores.sabersai.model.Nivel;
import com.lostreseditores.sabersai.model.Premarcado;
import com.lostreseditores.sabersai.model.Reportes;
import com.lostreseditores.sabersai.model.Respuestaxasignatura;
import com.lostreseditores.sabersai.model.Resultadodetallado;
import com.lostreseditores.sabersai.model.Resultadoxestudiante;
import com.lostreseditores.sabersai.model.Tipoexamen;
import com.lostreseditores.sabersai.model.Usuario;
import com.lostreseditores.sabersai.model.VSalones;
import com.lostreseditores.sabersai.model.control.AccesoLogic;
import com.lostreseditores.sabersai.model.control.AnalizaxrespuestaLogic;
import com.lostreseditores.sabersai.model.control.AsignaturaLogic;
import com.lostreseditores.sabersai.model.control.AsignaturaxcompetenciaLogic;
import com.lostreseditores.sabersai.model.control.AsignaturaxcomponenteLogic;
import com.lostreseditores.sabersai.model.control.AsignaturaxexamenLogic;
import com.lostreseditores.sabersai.model.control.BasesLogic;
import com.lostreseditores.sabersai.model.control.CalificacionLogic;
import com.lostreseditores.sabersai.model.control.CalificacionxestudianteLogic;
import com.lostreseditores.sabersai.model.control.CalificaperiodoLogic;
import com.lostreseditores.sabersai.model.control.ClaseasignaturaLogic;
import com.lostreseditores.sabersai.model.control.ColegioLogic;
import com.lostreseditores.sabersai.model.control.CompetenciaLogic;
import com.lostreseditores.sabersai.model.control.ComponenteLogic;
import com.lostreseditores.sabersai.model.control.ComunidadLogic;
import com.lostreseditores.sabersai.model.control.CursoLogic;
import com.lostreseditores.sabersai.model.control.DistribuidorLogic;
import com.lostreseditores.sabersai.model.control.EstudianteLogic;
import com.lostreseditores.sabersai.model.control.ExamenLogic;
import com.lostreseditores.sabersai.model.control.ExamenxreporteLogic;
import com.lostreseditores.sabersai.model.control.GeneroLogic;
import com.lostreseditores.sabersai.model.control.IAccesoLogic;
import com.lostreseditores.sabersai.model.control.IAnalizaxrespuestaLogic;
import com.lostreseditores.sabersai.model.control.IAsignaturaLogic;
import com.lostreseditores.sabersai.model.control.IAsignaturaxcompetenciaLogic;
import com.lostreseditores.sabersai.model.control.IAsignaturaxcomponenteLogic;
import com.lostreseditores.sabersai.model.control.IAsignaturaxexamenLogic;
import com.lostreseditores.sabersai.model.control.IBasesLogic;
import com.lostreseditores.sabersai.model.control.ICalificacionLogic;
import com.lostreseditores.sabersai.model.control.ICalificacionxestudianteLogic;
import com.lostreseditores.sabersai.model.control.ICalificaperiodoLogic;
import com.lostreseditores.sabersai.model.control.IClaseasignaturaLogic;
import com.lostreseditores.sabersai.model.control.IColegioLogic;
import com.lostreseditores.sabersai.model.control.ICompetenciaLogic;
import com.lostreseditores.sabersai.model.control.IComponenteLogic;
import com.lostreseditores.sabersai.model.control.IComunidadLogic;
import com.lostreseditores.sabersai.model.control.ICursoLogic;
import com.lostreseditores.sabersai.model.control.IDistribuidorLogic;
import com.lostreseditores.sabersai.model.control.IEstudianteLogic;
import com.lostreseditores.sabersai.model.control.IExamenLogic;
import com.lostreseditores.sabersai.model.control.IExamenxreporteLogic;
import com.lostreseditores.sabersai.model.control.IGeneroLogic;
import com.lostreseditores.sabersai.model.control.IJornadaLogic;
import com.lostreseditores.sabersai.model.control.ILogroLogic;
import com.lostreseditores.sabersai.model.control.ILugarLogic;
import com.lostreseditores.sabersai.model.control.IMenuLogic;
import com.lostreseditores.sabersai.model.control.INivelLogic;
import com.lostreseditores.sabersai.model.control.IPremarcadoLogic;
import com.lostreseditores.sabersai.model.control.IReportesLogic;
import com.lostreseditores.sabersai.model.control.IRespuestaxasignaturaLogic;
import com.lostreseditores.sabersai.model.control.IResultadodetalladoLogic;
import com.lostreseditores.sabersai.model.control.IResultadoxestudianteLogic;
import com.lostreseditores.sabersai.model.control.ITipoexamenLogic;
import com.lostreseditores.sabersai.model.control.IUsuarioLogic;
import com.lostreseditores.sabersai.model.control.JornadaLogic;
import com.lostreseditores.sabersai.model.control.LogroLogic;
import com.lostreseditores.sabersai.model.control.LugarLogic;
import com.lostreseditores.sabersai.model.control.MenuLogic;
import com.lostreseditores.sabersai.model.control.NivelLogic;
import com.lostreseditores.sabersai.model.control.PremarcadoLogic;
import com.lostreseditores.sabersai.model.control.ReportesLogic;
import com.lostreseditores.sabersai.model.control.RespuestaxasignaturaLogic;
import com.lostreseditores.sabersai.model.control.ResultadodetalladoLogic;
import com.lostreseditores.sabersai.model.control.ResultadoxestudianteLogic;
import com.lostreseditores.sabersai.model.control.TipoexamenLogic;
import com.lostreseditores.sabersai.model.control.UsuarioLogic;
import com.lostreseditores.sabersai.model.dto.AccesoDTO;
import com.lostreseditores.sabersai.model.dto.AnalizaxrespuestaDTO;
import com.lostreseditores.sabersai.model.dto.AsignaturaDTO;
import com.lostreseditores.sabersai.model.dto.AsignaturaxcompetenciaDTO;
import com.lostreseditores.sabersai.model.dto.AsignaturaxcomponenteDTO;
import com.lostreseditores.sabersai.model.dto.AsignaturaxexamenDTO;
import com.lostreseditores.sabersai.model.dto.BasesDTO;
import com.lostreseditores.sabersai.model.dto.CalificacionDTO;
import com.lostreseditores.sabersai.model.dto.CalificacionxestudianteDTO;
import com.lostreseditores.sabersai.model.dto.CalificaperiodoDTO;
import com.lostreseditores.sabersai.model.dto.ClaseasignaturaDTO;
import com.lostreseditores.sabersai.model.dto.ColegioDTO;
import com.lostreseditores.sabersai.model.dto.CompetenciaDTO;
import com.lostreseditores.sabersai.model.dto.ComponenteDTO;
import com.lostreseditores.sabersai.model.dto.ComunidadDTO;
import com.lostreseditores.sabersai.model.dto.CursoDTO;
import com.lostreseditores.sabersai.model.dto.DistribuidorDTO;
import com.lostreseditores.sabersai.model.dto.EstudianteDTO;
import com.lostreseditores.sabersai.model.dto.ExamenDTO;
import com.lostreseditores.sabersai.model.dto.ExamenxreporteDTO;
import com.lostreseditores.sabersai.model.dto.GeneroDTO;
import com.lostreseditores.sabersai.model.dto.JornadaDTO;
import com.lostreseditores.sabersai.model.dto.LogroDTO;
import com.lostreseditores.sabersai.model.dto.LugarDTO;
import com.lostreseditores.sabersai.model.dto.MenuDTO;
import com.lostreseditores.sabersai.model.dto.NivelDTO;
import com.lostreseditores.sabersai.model.dto.PremarcadoDTO;
import com.lostreseditores.sabersai.model.dto.ReportesDTO;
import com.lostreseditores.sabersai.model.dto.RespuestaxasignaturaDTO;
import com.lostreseditores.sabersai.model.dto.ResultadodetalladoDTO;
import com.lostreseditores.sabersai.model.dto.ResultadoxestudianteDTO;
import com.lostreseditores.sabersai.model.dto.TipoexamenDTO;
import com.lostreseditores.sabersai.model.dto.UsuarioDTO;


public class BusinessDelegatorView {
    private BusinessDelegatorView() {
    }

    public static List<Acceso> getAcceso() throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();

        return accesoLogic.getAcceso();
    }

    public static void saveAcceso(Integer acceidn, Integer menuidn_Menu,
        Integer niveidn_Nivel) throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();
        accesoLogic.saveAcceso(acceidn, menuidn_Menu, niveidn_Nivel);
    }

    public static void deleteAcceso(Integer acceidn) throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();
        accesoLogic.deleteAcceso(acceidn);
    }

    public static void updateAcceso(Integer acceidn, Integer menuidn_Menu,
        Integer niveidn_Nivel) throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();
        accesoLogic.updateAcceso(acceidn, menuidn_Menu, niveidn_Nivel);
    }

    public static Acceso getAcceso(Integer acceidn) throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();
        Acceso acceso = null;

        try {
            acceso = accesoLogic.getAcceso(acceidn);
        } catch (Exception e) {
            throw e;
        }

        return acceso;
    }

    public static List<Acceso> findByCriteriaInAcceso(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();

        return accesoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Acceso> findPageAcceso(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();

        return accesoLogic.findPageAcceso(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberAcceso() throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();

        return accesoLogic.findTotalNumberAcceso();
    }

    public static List<AccesoDTO> getDataAcceso() throws Exception {
        IAccesoLogic accesoLogic = new AccesoLogic();

        return accesoLogic.getDataAcceso();
    }

    public static List<Analizaxrespuesta> getAnalizaxrespuesta()
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();

        return analizaxrespuestaLogic.getAnalizaxrespuesta();
    }

    public static void saveAnalizaxrespuesta(String anaxresc1t,
        String anaxresc2t, String anaxresc3t, String anaxresc4t,
        String anaxresc5t, String anaxresc6t, String anaxresc7t,
        Integer anaxresestadon, Integer anaxresidn, Integer premidn_Premarcado)
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();
        analizaxrespuestaLogic.saveAnalizaxrespuesta(anaxresc1t, anaxresc2t,
            anaxresc3t, anaxresc4t, anaxresc5t, anaxresc6t, anaxresc7t,
            anaxresestadon, anaxresidn, premidn_Premarcado);
    }

    public static void deleteAnalizaxrespuesta(Integer anaxresidn)
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();
        analizaxrespuestaLogic.deleteAnalizaxrespuesta(anaxresidn);
    }

    public static void updateAnalizaxrespuesta(String anaxresc1t,
        String anaxresc2t, String anaxresc3t, String anaxresc4t,
        String anaxresc5t, String anaxresc6t, String anaxresc7t,
        Integer anaxresestadon, Integer anaxresidn, Integer premidn_Premarcado)
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();
        analizaxrespuestaLogic.updateAnalizaxrespuesta(anaxresc1t, anaxresc2t,
            anaxresc3t, anaxresc4t, anaxresc5t, anaxresc6t, anaxresc7t,
            anaxresestadon, anaxresidn, premidn_Premarcado);
    }

    public static Analizaxrespuesta getAnalizaxrespuesta(Integer anaxresidn)
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();
        Analizaxrespuesta analizaxrespuesta = null;

        try {
            analizaxrespuesta = analizaxrespuestaLogic.getAnalizaxrespuesta(anaxresidn);
        } catch (Exception e) {
            throw e;
        }

        return analizaxrespuesta;
    }

    public static List<Analizaxrespuesta> findByCriteriaInAnalizaxrespuesta(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();

        return analizaxrespuestaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Analizaxrespuesta> findPageAnalizaxrespuesta(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();

        return analizaxrespuestaLogic.findPageAnalizaxrespuesta(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAnalizaxrespuesta()
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();

        return analizaxrespuestaLogic.findTotalNumberAnalizaxrespuesta();
    }

    public static List<AnalizaxrespuestaDTO> getDataAnalizaxrespuesta()
        throws Exception {
        IAnalizaxrespuestaLogic analizaxrespuestaLogic = new AnalizaxrespuestaLogic();

        return analizaxrespuestaLogic.getDataAnalizaxrespuesta();
    }

    public static List<Asignatura> getAsignatura() throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();

        return asignaturaLogic.getAsignatura();
    }

    public static void saveAsignatura(String asigdescripv,
        Long asigdesvnacional, Long asigdesvnacsaber, Integer asigidn,
        Long asigpromnacional, Long asigpromnacsaber, Integer asigxexamordfn,
        Integer asigxexamordn2n, Integer asigxexamordnn,
        Integer asigxexamordsn, Integer clasasigidn_Claseasignatura)
        throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();
        asignaturaLogic.saveAsignatura(asigdescripv, asigdesvnacional,
            asigdesvnacsaber, asigidn, asigpromnacional, asigpromnacsaber,
            asigxexamordfn, asigxexamordn2n, asigxexamordnn, asigxexamordsn,
            clasasigidn_Claseasignatura);
    }

    public static void deleteAsignatura(Integer asigidn)
        throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();
        asignaturaLogic.deleteAsignatura(asigidn);
    }

    public static void updateAsignatura(String asigdescripv,
        Long asigdesvnacional, Long asigdesvnacsaber, Integer asigidn,
        Long asigpromnacional, Long asigpromnacsaber, Integer asigxexamordfn,
        Integer asigxexamordn2n, Integer asigxexamordnn,
        Integer asigxexamordsn, Integer clasasigidn_Claseasignatura)
        throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();
        asignaturaLogic.updateAsignatura(asigdescripv, asigdesvnacional,
            asigdesvnacsaber, asigidn, asigpromnacional, asigpromnacsaber,
            asigxexamordfn, asigxexamordn2n, asigxexamordnn, asigxexamordsn,
            clasasigidn_Claseasignatura);
    }

    public static Asignatura getAsignatura(Integer asigidn)
        throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();
        Asignatura asignatura = null;

        try {
            asignatura = asignaturaLogic.getAsignatura(asigidn);
        } catch (Exception e) {
            throw e;
        }

        return asignatura;
    }

    public static List<Asignatura> findByCriteriaInAsignatura(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();

        return asignaturaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Asignatura> findPageAsignatura(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();

        return asignaturaLogic.findPageAsignatura(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAsignatura() throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();

        return asignaturaLogic.findTotalNumberAsignatura();
    }

    public static List<AsignaturaDTO> getDataAsignatura()
        throws Exception {
        IAsignaturaLogic asignaturaLogic = new AsignaturaLogic();

        return asignaturaLogic.getDataAsignatura();
    }

    public static List<Asignaturaxcompetencia> getAsignaturaxcompetencia()
        throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();

        return asignaturaxcompetenciaLogic.getAsignaturaxcompetencia();
    }

    public static void saveAsignaturaxcompetencia(Integer asigxcomciaidn,
        Integer asigidn_Asignatura, Integer comciadn_Competencia)
        throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();
        asignaturaxcompetenciaLogic.saveAsignaturaxcompetencia(asigxcomciaidn,
            asigidn_Asignatura, comciadn_Competencia);
    }

    public static void deleteAsignaturaxcompetencia(Integer asigxcomciaidn)
        throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();
        asignaturaxcompetenciaLogic.deleteAsignaturaxcompetencia(asigxcomciaidn);
    }

    public static void updateAsignaturaxcompetencia(Integer asigxcomciaidn,
        Integer asigidn_Asignatura, Integer comciadn_Competencia)
        throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();
        asignaturaxcompetenciaLogic.updateAsignaturaxcompetencia(asigxcomciaidn,
            asigidn_Asignatura, comciadn_Competencia);
    }

    public static Asignaturaxcompetencia getAsignaturaxcompetencia(
        Integer asigxcomciaidn) throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();
        Asignaturaxcompetencia asignaturaxcompetencia = null;

        try {
            asignaturaxcompetencia = asignaturaxcompetenciaLogic.getAsignaturaxcompetencia(asigxcomciaidn);
        } catch (Exception e) {
            throw e;
        }

        return asignaturaxcompetencia;
    }

    public static List<Asignaturaxcompetencia> findByCriteriaInAsignaturaxcompetencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();

        return asignaturaxcompetenciaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Asignaturaxcompetencia> findPageAsignaturaxcompetencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();

        return asignaturaxcompetenciaLogic.findPageAsignaturaxcompetencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAsignaturaxcompetencia()
        throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();

        return asignaturaxcompetenciaLogic.findTotalNumberAsignaturaxcompetencia();
    }

    public static List<AsignaturaxcompetenciaDTO> getDataAsignaturaxcompetencia()
        throws Exception {
        IAsignaturaxcompetenciaLogic asignaturaxcompetenciaLogic = new AsignaturaxcompetenciaLogic();

        return asignaturaxcompetenciaLogic.getDataAsignaturaxcompetencia();
    }

    public static List<Asignaturaxcomponente> getAsignaturaxcomponente()
        throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();

        return asignaturaxcomponenteLogic.getAsignaturaxcomponente();
    }

    public static void saveAsignaturaxcomponente(Integer asigxcompciaidn,
        Integer asigidn_Asignatura, Integer compciaidn_Componente)
        throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();
        asignaturaxcomponenteLogic.saveAsignaturaxcomponente(asigxcompciaidn,
            asigidn_Asignatura, compciaidn_Componente);
    }

    public static void deleteAsignaturaxcomponente(Integer asigxcompciaidn)
        throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();
        asignaturaxcomponenteLogic.deleteAsignaturaxcomponente(asigxcompciaidn);
    }

    public static void updateAsignaturaxcomponente(Integer asigxcompciaidn,
        Integer asigidn_Asignatura, Integer compciaidn_Componente)
        throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();
        asignaturaxcomponenteLogic.updateAsignaturaxcomponente(asigxcompciaidn,
            asigidn_Asignatura, compciaidn_Componente);
    }

    public static Asignaturaxcomponente getAsignaturaxcomponente(
        Integer asigxcompciaidn) throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();
        Asignaturaxcomponente asignaturaxcomponente = null;

        try {
            asignaturaxcomponente = asignaturaxcomponenteLogic.getAsignaturaxcomponente(asigxcompciaidn);
        } catch (Exception e) {
            throw e;
        }

        return asignaturaxcomponente;
    }

    public static List<Asignaturaxcomponente> findByCriteriaInAsignaturaxcomponente(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();

        return asignaturaxcomponenteLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Asignaturaxcomponente> findPageAsignaturaxcomponente(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();

        return asignaturaxcomponenteLogic.findPageAsignaturaxcomponente(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAsignaturaxcomponente()
        throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();

        return asignaturaxcomponenteLogic.findTotalNumberAsignaturaxcomponente();
    }

    public static List<AsignaturaxcomponenteDTO> getDataAsignaturaxcomponente()
        throws Exception {
        IAsignaturaxcomponenteLogic asignaturaxcomponenteLogic = new AsignaturaxcomponenteLogic();

        return asignaturaxcomponenteLogic.getDataAsignaturaxcomponente();
    }

    public static List<Asignaturaxexamen> getAsignaturaxexamen()
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();

        return asignaturaxexamenLogic.getAsignaturaxexamen();
    }

    public static void saveAsignaturaxexamen(Integer asigxexamidn,
        Integer asigxexamordn, Integer asigxexampregn,
        Integer asigidn_Asignatura, Integer examidn_Examen)
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();
        asignaturaxexamenLogic.saveAsignaturaxexamen(asigxexamidn,
            asigxexamordn, asigxexampregn, asigidn_Asignatura, examidn_Examen);
    }

    public static void deleteAsignaturaxexamen(Integer asigxexamidn)
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();
        asignaturaxexamenLogic.deleteAsignaturaxexamen(asigxexamidn);
    }

    public static void updateAsignaturaxexamen(Integer asigxexamidn,
        Integer asigxexamordn, Integer asigxexampregn,
        Integer asigidn_Asignatura, Integer examidn_Examen)
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();
        asignaturaxexamenLogic.updateAsignaturaxexamen(asigxexamidn,
            asigxexamordn, asigxexampregn, asigidn_Asignatura, examidn_Examen);
    }

    public static Asignaturaxexamen getAsignaturaxexamen(Integer asigxexamidn)
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();
        Asignaturaxexamen asignaturaxexamen = null;

        try {
            asignaturaxexamen = asignaturaxexamenLogic.getAsignaturaxexamen(asigxexamidn);
        } catch (Exception e) {
            throw e;
        }

        return asignaturaxexamen;
    }

    public static List<Asignaturaxexamen> findByCriteriaInAsignaturaxexamen(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();

        return asignaturaxexamenLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Asignaturaxexamen> findPageAsignaturaxexamen(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();

        return asignaturaxexamenLogic.findPageAsignaturaxexamen(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAsignaturaxexamen()
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();

        return asignaturaxexamenLogic.findTotalNumberAsignaturaxexamen();
    }

    public static List<AsignaturaxexamenDTO> getDataAsignaturaxexamen()
        throws Exception {
        IAsignaturaxexamenLogic asignaturaxexamenLogic = new AsignaturaxexamenLogic();

        return asignaturaxexamenLogic.getDataAsignaturaxexamen();
    }

    public static List<Bases> getBases() throws Exception {
        IBasesLogic basesLogic = new BasesLogic();

        return basesLogic.getBases();
    }

    public static void saveBases(Integer baseidn, Long bcompetenciafinn,
        Long bcompetenciainin, Long bcomponentefinn, Long bcomponenteinin,
        String bdescripcionv, Long bdiferencian, Long bpromediofinn,
        Long bpromedioinin, Long btotalfinn, Long btotalinin)
        throws Exception {
        IBasesLogic basesLogic = new BasesLogic();
        basesLogic.saveBases(baseidn, bcompetenciafinn, bcompetenciainin,
            bcomponentefinn, bcomponenteinin, bdescripcionv, bdiferencian,
            bpromediofinn, bpromedioinin, btotalfinn, btotalinin);
    }

    public static void deleteBases(Integer baseidn) throws Exception {
        IBasesLogic basesLogic = new BasesLogic();
        basesLogic.deleteBases(baseidn);
    }

    public static void updateBases(Integer baseidn, Long bcompetenciafinn,
        Long bcompetenciainin, Long bcomponentefinn, Long bcomponenteinin,
        String bdescripcionv, Long bdiferencian, Long bpromediofinn,
        Long bpromedioinin, Long btotalfinn, Long btotalinin)
        throws Exception {
        IBasesLogic basesLogic = new BasesLogic();
        basesLogic.updateBases(baseidn, bcompetenciafinn, bcompetenciainin,
            bcomponentefinn, bcomponenteinin, bdescripcionv, bdiferencian,
            bpromediofinn, bpromedioinin, btotalfinn, btotalinin);
    }

    public static Bases getBases(Integer baseidn) throws Exception {
        IBasesLogic basesLogic = new BasesLogic();
        Bases bases = null;

        try {
            bases = basesLogic.getBases(baseidn);
        } catch (Exception e) {
            throw e;
        }

        return bases;
    }

    public static List<Bases> findByCriteriaInBases(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IBasesLogic basesLogic = new BasesLogic();

        return basesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Bases> findPageBases(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IBasesLogic basesLogic = new BasesLogic();

        return basesLogic.findPageBases(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberBases() throws Exception {
        IBasesLogic basesLogic = new BasesLogic();

        return basesLogic.findTotalNumberBases();
    }

    public static List<BasesDTO> getDataBases() throws Exception {
        IBasesLogic basesLogic = new BasesLogic();

        return basesLogic.getDataBases();
    }

    public static List<Calificacion> getCalificacion()
        throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();

        return calificacionLogic.getCalificacion();
    }

    public static void saveCalificacion(Integer caliestadon, Date califechad,
        Integer caliidn, Integer calipremarcan, Integer caliidn_Calificacion,
        Integer coleidn_Colegio, Integer cursidn_Curso,
 Integer distidn_Distribuidor,
			Integer examidn_Examen, Integer jornidn_Jornada,
			Integer usuaidn_Usuario) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.saveCalificacion(caliestadon, califechad, caliidn,
				calipremarcan, caliidn_Calificacion, coleidn_Colegio,
				cursidn_Curso, distidn_Distribuidor, examidn_Examen,
				jornidn_Jornada, usuaidn_Usuario);
	}

	public static void savePaquete(Integer cursidn_Curso,
			Integer coleidn_Colegio, Integer usuaidn_Usuario, Date califechad,
			Integer distidn_Distribuidor) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.savePaquete(cursidn_Curso, coleidn_Colegio,
				usuaidn_Usuario, califechad, distidn_Distribuidor);
	}

	public static void saveSalon(Integer cursidn_Curso,
			Integer usuaidn_Usuario, Date califechad, Integer cal_caliidn,
			Integer jornidn_Jornada) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.saveSalon(cursidn_Curso, usuaidn_Usuario, califechad,
				cal_caliidn, jornidn_Jornada);
	}
	
	public static void saveCalific(Integer usuaidn_Usuario, Date califechad,
			Integer examidn, Integer cal_caliidn, Integer caliestadon)
			throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.saveCalific(usuaidn_Usuario, califechad, examidn,
				cal_caliidn, caliestadon);
	}

	public static void deleteCalificacion(Integer caliidn) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.deleteCalificacion(caliidn);
	}
	
	public static void deletePaquete(Integer caliidn) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.deletePaquete(caliidn);
	}
	
	public static void deleteSalon(Integer caliidn) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.deleteSalon(caliidn);
	}

	public static void updateCalificacion(Integer caliestadon, Date califechad,
			Integer caliidn, Integer calipremarcan,
			Integer caliidn_Calificacion, Integer coleidn_Colegio,
			Integer cursidn_Curso, Integer distidn_Distribuidor,
			Integer examidn_Examen, Integer jornidn_Jornada,
			Integer usuaidn_Usuario) throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();
        calificacionLogic.updateCalificacion(caliestadon, califechad, caliidn,
            calipremarcan, caliidn_Calificacion, coleidn_Colegio,
            cursidn_Curso, distidn_Distribuidor, examidn_Examen,
            jornidn_Jornada, usuaidn_Usuario);
	}

	public static void updatePaquete(Integer caliidn, Integer cursidn_Curso,
			Integer distidn_Distribuidor) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.updatePaquete(caliidn, cursidn_Curso,
				distidn_Distribuidor);
	}
	
	public static void updateSalon(Integer caliidn, Integer cursidn_Curso,
			Integer jornidn_Jornada) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();
		calificacionLogic.updateSalon(caliidn, cursidn_Curso,
				jornidn_Jornada);
	}

	public static Calificacion getCalificacion(Integer caliidn)
        throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();
        Calificacion calificacion = null;

        try {
            calificacion = calificacionLogic.getCalificacion(caliidn);
        } catch (Exception e) {
            throw e;
        }

        return calificacion;
    }

    public static List<Calificacion> findByCriteriaInCalificacion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();

        return calificacionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Calificacion> findPageCalificacion(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();

        return calificacionLogic.findPageCalificacion(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCalificacion() throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();

        return calificacionLogic.findTotalNumberCalificacion();
    }

    public static List<CalificacionDTO> getDataCalificacion()
        throws Exception {
        ICalificacionLogic calificacionLogic = new CalificacionLogic();

        return calificacionLogic.getDataCalificacion();
    }

    public static List<Calificacionxestudiante> getCalificacionxestudiante()
        throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();

        return calificacionxestudianteLogic.getCalificacionxestudiante();
    }

/*    public static void saveCalificacionxestudiante(Integer caliactivon,
        Integer calicodauxn, Integer calipreorden, Integer calixestuidn,
        String calixesturespv, Integer caliidn_Calificacion,
        Integer estuidn_Estudiante, Integer examidn_Examen,
        Integer usuaidn_Usuario) throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();
        calificacionxestudianteLogic.saveCalificacionxestudiante(caliactivon,
            calicodauxn, calipreorden, calixestuidn, calixesturespv,
            caliidn_Calificacion, estuidn_Estudiante, examidn_Examen,
            usuaidn_Usuario);
    }*/
    
    public static void saveCalificacionxestudiante(Integer estuidn_Estudiante, Integer caliidn_Calificacion, Integer usuaidn_Usuario, Integer examidn_Examen) throws Exception {
            ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();
            calificacionxestudianteLogic.saveCalificacionxestudiante(estuidn_Estudiante,
            		caliidn_Calificacion, usuaidn_Usuario, examidn_Examen);
        }

    public static void deleteCalificacionxestudiante(Integer calixestuidn)
        throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();
        calificacionxestudianteLogic.deleteCalificacionxestudiante(calixestuidn);
    }

    public static void updateCalificacionxestudiante(Integer caliactivon,
        Integer calicodauxn, Integer calipreorden, Integer calixestuidn,
        String calixesturespv, Integer caliidn_Calificacion,
        Integer estuidn_Estudiante, Integer examidn_Examen,
        Integer usuaidn_Usuario) throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();
        calificacionxestudianteLogic.updateCalificacionxestudiante(caliactivon,
            calicodauxn, calipreorden, calixestuidn, calixesturespv,
            caliidn_Calificacion, estuidn_Estudiante, examidn_Examen,
            usuaidn_Usuario);
    }

    public static Calificacionxestudiante getCalificacionxestudiante(
        Integer calixestuidn) throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();
        Calificacionxestudiante calificacionxestudiante = null;

        try {
            calificacionxestudiante = calificacionxestudianteLogic.getCalificacionxestudiante(calixestuidn);
        } catch (Exception e) {
            throw e;
        }

        return calificacionxestudiante;
    }

    public static List<Calificacionxestudiante> findByCriteriaInCalificacionxestudiante(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();

        return calificacionxestudianteLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Calificacionxestudiante> findPageCalificacionxestudiante(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();

        return calificacionxestudianteLogic.findPageCalificacionxestudiante(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCalificacionxestudiante()
        throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();

        return calificacionxestudianteLogic.findTotalNumberCalificacionxestudiante();
    }

    public static List<CalificacionxestudianteDTO> getDataCalificacionxestudiante()
        throws Exception {
        ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();

        return calificacionxestudianteLogic.getDataCalificacionxestudiante();
    }

    public static List<Calificaperiodo> getCalificaperiodo()
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();

        return calificaperiodoLogic.getCalificaperiodo();
    }

    public static void saveCalificaperiodo(Integer asigidn,
        Integer califiperiodoidn, Integer calixestuidn, Long puntaje)
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();
        calificaperiodoLogic.saveCalificaperiodo(asigidn, califiperiodoidn,
            calixestuidn, puntaje);
    }

    public static void deleteCalificaperiodo(Integer califiperiodoidn)
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();
        calificaperiodoLogic.deleteCalificaperiodo(califiperiodoidn);
    }

    public static void updateCalificaperiodo(Integer asigidn,
        Integer califiperiodoidn, Integer calixestuidn, Long puntaje)
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();
        calificaperiodoLogic.updateCalificaperiodo(asigidn, califiperiodoidn,
            calixestuidn, puntaje);
    }

    public static Calificaperiodo getCalificaperiodo(Integer califiperiodoidn)
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();
        Calificaperiodo calificaperiodo = null;

        try {
            calificaperiodo = calificaperiodoLogic.getCalificaperiodo(califiperiodoidn);
        } catch (Exception e) {
            throw e;
        }

        return calificaperiodo;
    }

    public static List<Calificaperiodo> findByCriteriaInCalificaperiodo(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();

        return calificaperiodoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Calificaperiodo> findPageCalificaperiodo(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();

        return calificaperiodoLogic.findPageCalificaperiodo(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCalificaperiodo()
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();

        return calificaperiodoLogic.findTotalNumberCalificaperiodo();
    }

    public static List<CalificaperiodoDTO> getDataCalificaperiodo()
        throws Exception {
        ICalificaperiodoLogic calificaperiodoLogic = new CalificaperiodoLogic();

        return calificaperiodoLogic.getDataCalificaperiodo();
    }

    public static List<Claseasignatura> getClaseasignatura()
        throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();

        return claseasignaturaLogic.getClaseasignatura();
    }

    public static void saveClaseasignatura(String clasasigdescript,
        Integer clasasigidn) throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();
        claseasignaturaLogic.saveClaseasignatura(clasasigdescript, clasasigidn);
    }

    public static void deleteClaseasignatura(Integer clasasigidn)
        throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();
        claseasignaturaLogic.deleteClaseasignatura(clasasigidn);
    }

    public static void updateClaseasignatura(String clasasigdescript,
        Integer clasasigidn) throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();
        claseasignaturaLogic.updateClaseasignatura(clasasigdescript, clasasigidn);
    }

    public static Claseasignatura getClaseasignatura(Integer clasasigidn)
        throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();
        Claseasignatura claseasignatura = null;

        try {
            claseasignatura = claseasignaturaLogic.getClaseasignatura(clasasigidn);
        } catch (Exception e) {
            throw e;
        }

        return claseasignatura;
    }

    public static List<Claseasignatura> findByCriteriaInClaseasignatura(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();

        return claseasignaturaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Claseasignatura> findPageClaseasignatura(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();

        return claseasignaturaLogic.findPageClaseasignatura(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberClaseasignatura()
        throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();

        return claseasignaturaLogic.findTotalNumberClaseasignatura();
    }

    public static List<ClaseasignaturaDTO> getDataClaseasignatura()
        throws Exception {
        IClaseasignaturaLogic claseasignaturaLogic = new ClaseasignaturaLogic();

        return claseasignaturaLogic.getDataClaseasignatura();
    }

    public static List<Colegio> getColegio() throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();

        return colegioLogic.getColegio();
    }

	public static void saveColegio(Long colecoddanen, String coledescripv,
			Long lugaidn) throws Exception {
		IColegioLogic colegioLogic = new ColegioLogic();
		colegioLogic.saveColegio(colecoddanen, coledescripv, lugaidn);
	}

    public static void deleteColegio(Integer coleidn) throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();
        colegioLogic.deleteColegio(coleidn);
    }

    public static void updateColegio(Integer coleidn, Long colecoddanen, String coledescripv,
       Long lugaidn) throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();
        colegioLogic.updateColegio(coleidn, colecoddanen, coledescripv, lugaidn);
    }

    public static Colegio getColegio(Integer coleidn) throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();
        Colegio colegio = null;

        try {
            colegio = colegioLogic.getColegio(coleidn);
        } catch (Exception e) {
            throw e;
        }

        return colegio;
    }
    
    public static Colegio getColegioDane(Long coleDane) throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();
        //Colegio colegio = null;
        List<Colegio> colegios;
        try {
             colegios = colegioLogic.getColegioDane(coleDane);
        } catch (Exception e) {
            throw e;
        }

        return colegios.get(0);
    }

    public static List<Colegio> findByCriteriaInColegio(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();

        return colegioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Colegio> findPageColegio(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();

        return colegioLogic.findPageColegio(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberColegio() throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();

        return colegioLogic.findTotalNumberColegio();
    }

    public static List<ColegioDTO> getDataColegio() throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();

        return colegioLogic.getDataColegio();
    }

    public static List<Competencia> getCompetencia() throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();

        return competenciaLogic.getCompetencia();
    }

    public static void saveCompetencia(String comciadescripv, Integer comciadn,
        String comciasiglav) throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();
        competenciaLogic.saveCompetencia(comciadescripv, comciadn, comciasiglav);
    }

    public static void deleteCompetencia(Integer comciadn)
        throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();
        competenciaLogic.deleteCompetencia(comciadn);
    }

    public static void updateCompetencia(String comciadescripv,
        Integer comciadn, String comciasiglav) throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();
        competenciaLogic.updateCompetencia(comciadescripv, comciadn,
            comciasiglav);
    }

    public static Competencia getCompetencia(Integer comciadn)
        throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();
        Competencia competencia = null;

        try {
            competencia = competenciaLogic.getCompetencia(comciadn);
        } catch (Exception e) {
            throw e;
        }

        return competencia;
    }

    public static List<Competencia> findByCriteriaInCompetencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();

        return competenciaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Competencia> findPageCompetencia(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();

        return competenciaLogic.findPageCompetencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCompetencia() throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();

        return competenciaLogic.findTotalNumberCompetencia();
    }

    public static List<CompetenciaDTO> getDataCompetencia()
        throws Exception {
        ICompetenciaLogic competenciaLogic = new CompetenciaLogic();

        return competenciaLogic.getDataCompetencia();
    }

    public static List<Componente> getComponente() throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();

        return componenteLogic.getComponente();
    }

    public static void saveComponente(String compciadescript,
        Integer compciaidn, String compciasiglav) throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();
        componenteLogic.saveComponente(compciadescript, compciaidn,
            compciasiglav);
    }

    public static void deleteComponente(Integer compciaidn)
        throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();
        componenteLogic.deleteComponente(compciaidn);
    }

    public static void updateComponente(String compciadescript,
        Integer compciaidn, String compciasiglav) throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();
        componenteLogic.updateComponente(compciadescript, compciaidn,
            compciasiglav);
    }

    public static Componente getComponente(Integer compciaidn)
        throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();
        Componente componente = null;

        try {
            componente = componenteLogic.getComponente(compciaidn);
        } catch (Exception e) {
            throw e;
        }

        return componente;
    }

    public static List<Componente> findByCriteriaInComponente(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();

        return componenteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Componente> findPageComponente(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();

        return componenteLogic.findPageComponente(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberComponente() throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();

        return componenteLogic.findTotalNumberComponente();
    }

    public static List<ComponenteDTO> getDataComponente()
        throws Exception {
        IComponenteLogic componenteLogic = new ComponenteLogic();

        return componenteLogic.getDataComponente();
    }

    public static List<Comunidad> getComunidad() throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();

        return comunidadLogic.getComunidad();
    }

    public static void saveComunidad(String comudescripv, Integer comuidn)
        throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();
        comunidadLogic.saveComunidad(comudescripv, comuidn);
    }

    public static void deleteComunidad(Integer comuidn)
        throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();
        comunidadLogic.deleteComunidad(comuidn);
    }

    public static void updateComunidad(String comudescripv, Integer comuidn)
        throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();
        comunidadLogic.updateComunidad(comudescripv, comuidn);
    }

    public static Comunidad getComunidad(Integer comuidn)
        throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();
        Comunidad comunidad = null;

        try {
            comunidad = comunidadLogic.getComunidad(comuidn);
        } catch (Exception e) {
            throw e;
        }

        return comunidad;
    }

    public static List<Comunidad> findByCriteriaInComunidad(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();

        return comunidadLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Comunidad> findPageComunidad(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();

        return comunidadLogic.findPageComunidad(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberComunidad() throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();

        return comunidadLogic.findTotalNumberComunidad();
    }

    public static List<ComunidadDTO> getDataComunidad()
        throws Exception {
        IComunidadLogic comunidadLogic = new ComunidadLogic();

        return comunidadLogic.getDataComunidad();
    }

    public static List<Curso> getCurso() throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.getCurso();
    }

    public static void saveCurso(String cursdescripv, Integer cursidn,
        String cursnombrev, Integer cursidn_Curso) throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();
        cursoLogic.saveCurso(cursdescripv, cursidn, cursnombrev, cursidn_Curso);
    }

    public static void deleteCurso(Integer cursidn) throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();
        cursoLogic.deleteCurso(cursidn);
    }

    public static void updateCurso(String cursdescripv, Integer cursidn,
        String cursnombrev, Integer cursidn_Curso) throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();
        cursoLogic.updateCurso(cursdescripv, cursidn, cursnombrev, cursidn_Curso);
    }

    public static Curso getCurso(Integer cursidn) throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();
        Curso curso = null;

        try {
            curso = cursoLogic.getCurso(cursidn);
        } catch (Exception e) {
            throw e;
        }

        return curso;
    }

    public static List<Curso> findByCriteriaInCurso(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Curso> findPageCurso(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.findPageCurso(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCurso() throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.findTotalNumberCurso();
    }

    public static List<CursoDTO> getDataCurso() throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.getDataCurso();
    }

    public static List<Distribuidor> getDistribuidor()
        throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();

        return distribuidorLogic.getDistribuidor();
    }

    public static void saveDistribuidor(String distcorreov, Integer distidn,
        String distmovilv, String distnombrev, String disttelefonov)
        throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();
        distribuidorLogic.saveDistribuidor(distcorreov, distidn, distmovilv,
            distnombrev, disttelefonov);
    }

    public static void deleteDistribuidor(Integer distidn)
        throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();
        distribuidorLogic.deleteDistribuidor(distidn);
    }

    public static void updateDistribuidor(String distcorreov, Integer distidn,
        String distmovilv, String distnombrev, String disttelefonov)
        throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();
        distribuidorLogic.updateDistribuidor(distcorreov, distidn, distmovilv,
            distnombrev, disttelefonov);
    }

    public static Distribuidor getDistribuidor(Integer distidn)
        throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();
        Distribuidor distribuidor = null;

        try {
            distribuidor = distribuidorLogic.getDistribuidor(distidn);
        } catch (Exception e) {
            throw e;
        }

        return distribuidor;
    }

    public static List<Distribuidor> findByCriteriaInDistribuidor(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();

        return distribuidorLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Distribuidor> findPageDistribuidor(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();

        return distribuidorLogic.findPageDistribuidor(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberDistribuidor() throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();

        return distribuidorLogic.findTotalNumberDistribuidor();
    }

    public static List<DistribuidorDTO> getDataDistribuidor()
        throws Exception {
        IDistribuidorLogic distribuidorLogic = new DistribuidorLogic();

        return distribuidorLogic.getDataDistribuidor();
    }

    public static List<Estudiante> getEstudiante() throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();

        return estudianteLogic.getEstudiante();
    }
   
    public static Estudiante saveEstudiante(String estunombrev,
            Integer geneidn_Genero, String codigoEstudiante) throws Exception {
            IEstudianteLogic estudianteLogic = new EstudianteLogic();
            return estudianteLogic.saveEstudiante(estunombrev, geneidn_Genero, codigoEstudiante);
        }

    public static void deleteEstudiante(Integer estuidn)
        throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();
        estudianteLogic.deleteEstudiante(estuidn);
    }

    public static void updateEstudiante(String estucodigov, String estudocumv,
        String estuemailv, Integer estuidn, String estunombrev,
        Integer geneidn_Genero) throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();
        estudianteLogic.updateEstudiante(estucodigov, estudocumv, estuemailv,
            estuidn, estunombrev, geneidn_Genero);
    }

    public static Estudiante getEstudiante(Integer estuidn)
        throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();
        Estudiante estudiante = null;

        try {
            estudiante = estudianteLogic.getEstudiante(estuidn);
        } catch (Exception e) {
            throw e;
        }

        return estudiante;
    }

    public static List<Estudiante> findByCriteriaInEstudiante(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();

        return estudianteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Estudiante> findPageEstudiante(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();

        return estudianteLogic.findPageEstudiante(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberEstudiante() throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();

        return estudianteLogic.findTotalNumberEstudiante();
    }

    public static List<EstudianteDTO> getDataEstudiante()
        throws Exception {
        IEstudianteLogic estudianteLogic = new EstudianteLogic();

        return estudianteLogic.getDataEstudiante();
    }

    public static List<Examen> getExamen() throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();

        return examenLogic.getExamen();
    }
    
    public static List<Examen> getExamenPorTipoExamen(Integer tipoExamen) throws Exception {
    	  IExamenLogic examenLogic = new ExamenLogic();

          return examenLogic.getExamenPorTipoExamen(tipoExamen);
    }

    public static void saveExamen(Integer exagrado, String examdescript,
        Integer examestadon, Integer examidn, String examnombrev,
        Integer examordenn, Integer baseidn_Bases, Integer examidn_Examen,
        Integer tipoexamidn_Tipoexamen) throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();
        examenLogic.saveExamen(exagrado, examdescript, examestadon, examidn,
            examnombrev, examordenn, baseidn_Bases, examidn_Examen,
            tipoexamidn_Tipoexamen);
    }

    public static void deleteExamen(Integer examidn) throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();
        examenLogic.deleteExamen(examidn);
    }

    public static void updateExamen(Integer exagrado, String examdescript,
        Integer examestadon, Integer examidn, String examnombrev,
        Integer examordenn, Integer baseidn_Bases, Integer examidn_Examen,
        Integer tipoexamidn_Tipoexamen) throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();
        examenLogic.updateExamen(exagrado, examdescript, examestadon, examidn,
            examnombrev, examordenn, baseidn_Bases, examidn_Examen,
            tipoexamidn_Tipoexamen);
    }

    public static Examen getExamen(Integer examidn) throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();
        Examen examen = null;

        try {
            examen = examenLogic.getExamen(examidn);
        } catch (Exception e) {
            throw e;
        }

        return examen;
    }

    public static List<Examen> findByCriteriaInExamen(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();

        return examenLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Examen> findPageExamen(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();

        return examenLogic.findPageExamen(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberExamen() throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();

        return examenLogic.findTotalNumberExamen();
    }

    public static List<ExamenDTO> getDataExamen() throws Exception {
        IExamenLogic examenLogic = new ExamenLogic();

        return examenLogic.getDataExamen();
    }

    public static List<Examenxreporte> getExamenxreporte()
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();

        return examenxreporteLogic.getExamenxreporte();
    }

    public static void saveExamenxreporte(Integer examxrepgeneraln,
        Integer examxrepoactivn, Integer examxrepoidn, Integer examxrepunionn,
        Integer reporidn_Reportes, Integer tipoexamidn_Tipoexamen)
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();
        examenxreporteLogic.saveExamenxreporte(examxrepgeneraln,
            examxrepoactivn, examxrepoidn, examxrepunionn, reporidn_Reportes,
            tipoexamidn_Tipoexamen);
    }

    public static void deleteExamenxreporte(Integer examxrepoidn)
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();
        examenxreporteLogic.deleteExamenxreporte(examxrepoidn);
    }

    public static void updateExamenxreporte(Integer examxrepgeneraln,
        Integer examxrepoactivn, Integer examxrepoidn, Integer examxrepunionn,
        Integer reporidn_Reportes, Integer tipoexamidn_Tipoexamen)
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();
        examenxreporteLogic.updateExamenxreporte(examxrepgeneraln,
            examxrepoactivn, examxrepoidn, examxrepunionn, reporidn_Reportes,
            tipoexamidn_Tipoexamen);
    }

    public static Examenxreporte getExamenxreporte(Integer examxrepoidn)
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();
        Examenxreporte examenxreporte = null;

        try {
            examenxreporte = examenxreporteLogic.getExamenxreporte(examxrepoidn);
        } catch (Exception e) {
            throw e;
        }

        return examenxreporte;
    }

    public static List<Examenxreporte> findByCriteriaInExamenxreporte(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();

        return examenxreporteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Examenxreporte> findPageExamenxreporte(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();

        return examenxreporteLogic.findPageExamenxreporte(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberExamenxreporte()
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();

        return examenxreporteLogic.findTotalNumberExamenxreporte();
    }

    public static List<ExamenxreporteDTO> getDataExamenxreporte()
        throws Exception {
        IExamenxreporteLogic examenxreporteLogic = new ExamenxreporteLogic();

        return examenxreporteLogic.getDataExamenxreporte();
    }

    public static List<Genero> getGenero() throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();

        return generoLogic.getGenero();
    }

    public static void saveGenero(String genedescripv, Integer geneidn,
        String genesiglav) throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();
        generoLogic.saveGenero(genedescripv, geneidn, genesiglav);
    }

    public static void deleteGenero(Integer geneidn) throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();
        generoLogic.deleteGenero(geneidn);
    }

    public static void updateGenero(String genedescripv, Integer geneidn,
        String genesiglav) throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();
        generoLogic.updateGenero(genedescripv, geneidn, genesiglav);
    }

    public static Genero getGenero(Integer geneidn) throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();
        Genero genero = null;

        try {
            genero = generoLogic.getGenero(geneidn);
        } catch (Exception e) {
            throw e;
        }

        return genero;
    }

    public static List<Genero> findByCriteriaInGenero(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();

        return generoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Genero> findPageGenero(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();

        return generoLogic.findPageGenero(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberGenero() throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();

        return generoLogic.findTotalNumberGenero();
    }

    public static List<GeneroDTO> getDataGenero() throws Exception {
        IGeneroLogic generoLogic = new GeneroLogic();

        return generoLogic.getDataGenero();
    }

    public static List<Jornada> getJornada() throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();

        return jornadaLogic.getJornada();
    }

    public static void saveJornada(String jorndescripv, Integer jornidn)
        throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();
        jornadaLogic.saveJornada(jorndescripv, jornidn);
    }

    public static void deleteJornada(Integer jornidn) throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();
        jornadaLogic.deleteJornada(jornidn);
    }

    public static void updateJornada(String jorndescripv, Integer jornidn)
        throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();
        jornadaLogic.updateJornada(jorndescripv, jornidn);
    }

    public static Jornada getJornada(Integer jornidn) throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();
        Jornada jornada = null;

        try {
            jornada = jornadaLogic.getJornada(jornidn);
        } catch (Exception e) {
            throw e;
        }

        return jornada;
    }

    public static List<Jornada> findByCriteriaInJornada(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();

        return jornadaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Jornada> findPageJornada(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();

        return jornadaLogic.findPageJornada(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberJornada() throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();

        return jornadaLogic.findTotalNumberJornada();
    }

    public static List<JornadaDTO> getDataJornada() throws Exception {
        IJornadaLogic jornadaLogic = new JornadaLogic();

        return jornadaLogic.getDataJornada();
    }

    public static List<Logro> getLogro() throws Exception {
        ILogroLogic logroLogic = new LogroLogic();

        return logroLogic.getLogro();
    }

    public static void saveLogro(String logrdescript, Integer logridn,
        String logrletrav, Long logrpuntajefinn, Long logrpuntajeinin,
        Integer respidn, Integer asigidn_Asignatura, Integer cursidn_Curso,
        Integer tipoexamidn_Tipoexamen) throws Exception {
        ILogroLogic logroLogic = new LogroLogic();
        logroLogic.saveLogro(logrdescript, logridn, logrletrav,
            logrpuntajefinn, logrpuntajeinin, respidn, asigidn_Asignatura,
            cursidn_Curso, tipoexamidn_Tipoexamen);
    }

    public static void deleteLogro(Integer logridn) throws Exception {
        ILogroLogic logroLogic = new LogroLogic();
        logroLogic.deleteLogro(logridn);
    }

    public static void updateLogro(String logrdescript, Integer logridn,
        String logrletrav, Long logrpuntajefinn, Long logrpuntajeinin,
        Integer respidn, Integer asigidn_Asignatura, Integer cursidn_Curso,
        Integer tipoexamidn_Tipoexamen) throws Exception {
        ILogroLogic logroLogic = new LogroLogic();
        logroLogic.updateLogro(logrdescript, logridn, logrletrav,
            logrpuntajefinn, logrpuntajeinin, respidn, asigidn_Asignatura,
            cursidn_Curso, tipoexamidn_Tipoexamen);
    }

    public static Logro getLogro(Integer logridn) throws Exception {
        ILogroLogic logroLogic = new LogroLogic();
        Logro logro = null;

        try {
            logro = logroLogic.getLogro(logridn);
        } catch (Exception e) {
            throw e;
        }

        return logro;
    }

    public static List<Logro> findByCriteriaInLogro(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ILogroLogic logroLogic = new LogroLogic();

        return logroLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Logro> findPageLogro(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ILogroLogic logroLogic = new LogroLogic();

        return logroLogic.findPageLogro(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberLogro() throws Exception {
        ILogroLogic logroLogic = new LogroLogic();

        return logroLogic.findTotalNumberLogro();
    }

    public static List<LogroDTO> getDataLogro() throws Exception {
        ILogroLogic logroLogic = new LogroLogic();

        return logroLogic.getDataLogro();
    }

    public static List<Lugar> getLugar() throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.getLugar();
    }
    
    
    public static List<Lugar> getDptos() throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.getDptos();
    }
    
    public static List<Lugar> getCiudades(Integer lugaidn) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.getCiudades(lugaidn);
    }
    

    public static void saveLugar(Long lugacoddanen, String lugadescripv,
        Integer lugaidn, Integer lugaidn_Lugar) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();
        lugarLogic.saveLugar(lugacoddanen, lugadescripv, lugaidn, lugaidn_Lugar);
    }

    public static void deleteLugar(Integer lugaidn) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();
        lugarLogic.deleteLugar(lugaidn);
    }

    public static void updateLugar(Long lugacoddanen, String lugadescripv,
        Integer lugaidn, Integer lugaidn_Lugar) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();
        lugarLogic.updateLugar(lugacoddanen, lugadescripv, lugaidn,
            lugaidn_Lugar);
    }

    public static Lugar getLugar(Integer lugaidn) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();
        Lugar lugar = null;

        try {
            lugar = lugarLogic.getLugar(lugaidn);
        } catch (Exception e) {
            throw e;
        }

        return lugar;
    }
    
    public static Lugar getLugarDane(Long lugaidn) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();
        Lugar lugar = null;

        try {
            lugar = lugarLogic.getLugarDane(lugaidn);
        } catch (Exception e) {
            throw e;
        }

        return lugar;
    }

    public static List<Lugar> findByCriteriaInLugar(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Lugar> findPageLugar(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.findPageLugar(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberLugar() throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.findTotalNumberLugar();
    }

    public static List<LugarDTO> getDataLugar() throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.getDataLugar();
    }

    public static List<Menu> getMenu() throws Exception {
        IMenuLogic menuLogic = new MenuLogic();

        return menuLogic.getMenu();
    }

    public static void saveMenu(Integer menuidn, String menuimagenv,
        String menunombrev, String menupaginav, Integer menuidn_Menu)
        throws Exception {
        IMenuLogic menuLogic = new MenuLogic();
        menuLogic.saveMenu(menuidn, menuimagenv, menunombrev, menupaginav,
            menuidn_Menu);
    }

    public static void deleteMenu(Integer menuidn) throws Exception {
        IMenuLogic menuLogic = new MenuLogic();
        menuLogic.deleteMenu(menuidn);
    }

    public static void updateMenu(Integer menuidn, String menuimagenv,
        String menunombrev, String menupaginav, Integer menuidn_Menu)
        throws Exception {
        IMenuLogic menuLogic = new MenuLogic();
        menuLogic.updateMenu(menuidn, menuimagenv, menunombrev, menupaginav,
            menuidn_Menu);
    }

    public static Menu getMenu(Integer menuidn) throws Exception {
        IMenuLogic menuLogic = new MenuLogic();
        Menu menu = null;

        try {
            menu = menuLogic.getMenu(menuidn);
        } catch (Exception e) {
            throw e;
        }

        return menu;
    }

    public static List<Menu> findByCriteriaInMenu(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IMenuLogic menuLogic = new MenuLogic();

        return menuLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Menu> findPageMenu(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IMenuLogic menuLogic = new MenuLogic();

        return menuLogic.findPageMenu(sortColumnName, sortAscending, startRow,
            maxResults);
    }

    public static Long findTotalNumberMenu() throws Exception {
        IMenuLogic menuLogic = new MenuLogic();

        return menuLogic.findTotalNumberMenu();
    }

    public static List<MenuDTO> getDataMenu() throws Exception {
        IMenuLogic menuLogic = new MenuLogic();

        return menuLogic.getDataMenu();
    }

    public static List<Nivel> getNivel() throws Exception {
        INivelLogic nivelLogic = new NivelLogic();

        return nivelLogic.getNivel();
    }

    public static void saveNivel(Integer niveidn, String nivenombrev,
        String nivepaginav) throws Exception {
        INivelLogic nivelLogic = new NivelLogic();
        nivelLogic.saveNivel(niveidn, nivenombrev, nivepaginav);
    }

    public static void deleteNivel(Integer niveidn) throws Exception {
        INivelLogic nivelLogic = new NivelLogic();
        nivelLogic.deleteNivel(niveidn);
    }

    public static void updateNivel(Integer niveidn, String nivenombrev,
        String nivepaginav) throws Exception {
        INivelLogic nivelLogic = new NivelLogic();
        nivelLogic.updateNivel(niveidn, nivenombrev, nivepaginav);
    }

    public static Nivel getNivel(Integer niveidn) throws Exception {
        INivelLogic nivelLogic = new NivelLogic();
        Nivel nivel = null;

        try {
            nivel = nivelLogic.getNivel(niveidn);
        } catch (Exception e) {
            throw e;
        }

        return nivel;
    }

    public static List<Nivel> findByCriteriaInNivel(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        INivelLogic nivelLogic = new NivelLogic();

        return nivelLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Nivel> findPageNivel(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        INivelLogic nivelLogic = new NivelLogic();

        return nivelLogic.findPageNivel(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberNivel() throws Exception {
        INivelLogic nivelLogic = new NivelLogic();

        return nivelLogic.findTotalNumberNivel();
    }

    public static List<NivelDTO> getDataNivel() throws Exception {
        INivelLogic nivelLogic = new NivelLogic();

        return nivelLogic.getDataNivel();
    }

    public static List<Premarcado> getPremarcado() throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();

        return premarcadoLogic.getPremarcado();
    }

    public static void savePremarcado(String premarchivot, String premcodasigt,
        Integer premestadon, Date premfechad, Integer premidn,
        Integer premtipon, Integer caliidn_Calificacion)
        throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();
        premarcadoLogic.savePremarcado(premarchivot, premcodasigt, premestadon,
            premfechad, premidn, premtipon, caliidn_Calificacion);
    }

    public static void deletePremarcado(Integer premidn)
        throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();
        premarcadoLogic.deletePremarcado(premidn);
    }

    public static void updatePremarcado(String premarchivot,
        String premcodasigt, Integer premestadon, Date premfechad,
        Integer premidn, Integer premtipon, Integer caliidn_Calificacion)
        throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();
        premarcadoLogic.updatePremarcado(premarchivot, premcodasigt,
            premestadon, premfechad, premidn, premtipon, caliidn_Calificacion);
    }

    public static Premarcado getPremarcado(Integer premidn)
        throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();
        Premarcado premarcado = null;

        try {
            premarcado = premarcadoLogic.getPremarcado(premidn);
        } catch (Exception e) {
            throw e;
        }

        return premarcado;
    }

    public static List<Premarcado> findByCriteriaInPremarcado(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();

        return premarcadoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Premarcado> findPagePremarcado(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();

        return premarcadoLogic.findPagePremarcado(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPremarcado() throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();

        return premarcadoLogic.findTotalNumberPremarcado();
    }

    public static List<PremarcadoDTO> getDataPremarcado()
        throws Exception {
        IPremarcadoLogic premarcadoLogic = new PremarcadoLogic();

        return premarcadoLogic.getDataPremarcado();
    }

    public static List<Reportes> getReportes() throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();

        return reportesLogic.getReportes();
    }

    public static void saveReportes(String nombrearchivo, String repordescripv,
        Integer reporidn) throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();
        reportesLogic.saveReportes(nombrearchivo, repordescripv, reporidn);
    }

    public static void deleteReportes(Integer reporidn)
        throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();
        reportesLogic.deleteReportes(reporidn);
    }

    public static void updateReportes(String nombrearchivo,
        String repordescripv, Integer reporidn) throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();
        reportesLogic.updateReportes(nombrearchivo, repordescripv, reporidn);
    }

    public static Reportes getReportes(Integer reporidn)
        throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();
        Reportes reportes = null;

        try {
            reportes = reportesLogic.getReportes(reporidn);
        } catch (Exception e) {
            throw e;
        }

        return reportes;
    }

    public static List<Reportes> findByCriteriaInReportes(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();

        return reportesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Reportes> findPageReportes(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();

        return reportesLogic.findPageReportes(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberReportes() throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();

        return reportesLogic.findTotalNumberReportes();
    }

    public static List<ReportesDTO> getDataReportes() throws Exception {
        IReportesLogic reportesLogic = new ReportesLogic();

        return reportesLogic.getDataReportes();
    }

    public static List<Respuestaxasignatura> getRespuestaxasignatura()
        throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();

        return respuestaxasignaturaLogic.getRespuestaxasignatura();
    }

    public static void saveRespuestaxasignatura(Integer respxasigactivon,
        String respxasigcorrecv, Integer respxasigdifn, Integer respxasigidn,
        String respxasignivdesv, String respxasigniveldesv,
        Integer respxasigopan, Integer respxasigopbn, Integer respxasigopcn,
        Integer respxasigopdn, Integer respxasigordenn,
        Integer respxasigpregespn, Integer respxasigtxtn,
        Integer asigxexamidn_Asignaturaxexamen, Integer comciadn_Competencia,
        Integer compciaidn_Componente) throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();
        respuestaxasignaturaLogic.saveRespuestaxasignatura(respxasigactivon,
            respxasigcorrecv, respxasigdifn, respxasigidn, respxasignivdesv,
            respxasigniveldesv, respxasigopan, respxasigopbn, respxasigopcn,
            respxasigopdn, respxasigordenn, respxasigpregespn, respxasigtxtn,
            asigxexamidn_Asignaturaxexamen, comciadn_Competencia,
            compciaidn_Componente);
    }

    public static void deleteRespuestaxasignatura(Integer respxasigidn)
        throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();
        respuestaxasignaturaLogic.deleteRespuestaxasignatura(respxasigidn);
    }

    public static void updateRespuestaxasignatura(Integer respxasigactivon,
        String respxasigcorrecv, Integer respxasigdifn, Integer respxasigidn,
        String respxasignivdesv, String respxasigniveldesv,
        Integer respxasigopan, Integer respxasigopbn, Integer respxasigopcn,
        Integer respxasigopdn, Integer respxasigordenn,
        Integer respxasigpregespn, Integer respxasigtxtn,
        Integer asigxexamidn_Asignaturaxexamen, Integer comciadn_Competencia,
        Integer compciaidn_Componente) throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();
        respuestaxasignaturaLogic.updateRespuestaxasignatura(respxasigactivon,
            respxasigcorrecv, respxasigdifn, respxasigidn, respxasignivdesv,
            respxasigniveldesv, respxasigopan, respxasigopbn, respxasigopcn,
            respxasigopdn, respxasigordenn, respxasigpregespn, respxasigtxtn,
            asigxexamidn_Asignaturaxexamen, comciadn_Competencia,
            compciaidn_Componente);
    }

    public static Respuestaxasignatura getRespuestaxasignatura(
        Integer respxasigidn) throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();
        Respuestaxasignatura respuestaxasignatura = null;

        try {
            respuestaxasignatura = respuestaxasignaturaLogic.getRespuestaxasignatura(respxasigidn);
        } catch (Exception e) {
            throw e;
        }

        return respuestaxasignatura;
    }

    public static List<Respuestaxasignatura> findByCriteriaInRespuestaxasignatura(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();

        return respuestaxasignaturaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Respuestaxasignatura> findPageRespuestaxasignatura(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();

        return respuestaxasignaturaLogic.findPageRespuestaxasignatura(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberRespuestaxasignatura()
        throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();

        return respuestaxasignaturaLogic.findTotalNumberRespuestaxasignatura();
    }

    public static List<RespuestaxasignaturaDTO> getDataRespuestaxasignatura()
        throws Exception {
        IRespuestaxasignaturaLogic respuestaxasignaturaLogic = new RespuestaxasignaturaLogic();

        return respuestaxasignaturaLogic.getDataRespuestaxasignatura();
    }

    public static List<Resultadodetallado> getResultadodetallado()
        throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();

        return resultadodetalladoLogic.getResultadodetallado();
    }

    public static void saveResultadodetallado(Integer resuldetaidn,
        Integer resuldetncorren, Integer resuldetniveln,
        Integer comciadn_Competencia, Integer compciaidn_Componente,
        Integer resulxestuidn_Resultadoxestudiante) throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();
        resultadodetalladoLogic.saveResultadodetallado(resuldetaidn,
            resuldetncorren, resuldetniveln, comciadn_Competencia,
            compciaidn_Componente, resulxestuidn_Resultadoxestudiante);
    }

    public static void deleteResultadodetallado(Integer resuldetaidn)
        throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();
        resultadodetalladoLogic.deleteResultadodetallado(resuldetaidn);
    }

    public static void updateResultadodetallado(Integer resuldetaidn,
        Integer resuldetncorren, Integer resuldetniveln,
        Integer comciadn_Competencia, Integer compciaidn_Componente,
        Integer resulxestuidn_Resultadoxestudiante) throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();
        resultadodetalladoLogic.updateResultadodetallado(resuldetaidn,
            resuldetncorren, resuldetniveln, comciadn_Competencia,
            compciaidn_Componente, resulxestuidn_Resultadoxestudiante);
    }

    public static Resultadodetallado getResultadodetallado(Integer resuldetaidn)
        throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();
        Resultadodetallado resultadodetallado = null;

        try {
            resultadodetallado = resultadodetalladoLogic.getResultadodetallado(resuldetaidn);
        } catch (Exception e) {
            throw e;
        }

        return resultadodetallado;
    }

    public static List<Resultadodetallado> findByCriteriaInResultadodetallado(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();

        return resultadodetalladoLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Resultadodetallado> findPageResultadodetallado(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();

        return resultadodetalladoLogic.findPageResultadodetallado(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberResultadodetallado()
        throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();

        return resultadodetalladoLogic.findTotalNumberResultadodetallado();
    }

    public static List<ResultadodetalladoDTO> getDataResultadodetallado()
        throws Exception {
        IResultadodetalladoLogic resultadodetalladoLogic = new ResultadodetalladoLogic();

        return resultadodetalladoLogic.getDataResultadodetallado();
    }

    public static List<Resultadoxestudiante> getResultadoxestudiante()
        throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();

        return resultadoxestudianteLogic.getResultadoxestudiante();
    }

    public static void saveResultadoxestudiante(Integer resulxestuidn,
        Integer asigxexamidn_Asignaturaxexamen,
        Integer calixestuidn_Calificacionxestudiante) throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();
        resultadoxestudianteLogic.saveResultadoxestudiante(resulxestuidn,
            asigxexamidn_Asignaturaxexamen, calixestuidn_Calificacionxestudiante);
    }

    public static void deleteResultadoxestudiante(Integer resulxestuidn)
        throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();
        resultadoxestudianteLogic.deleteResultadoxestudiante(resulxestuidn);
    }

    public static void updateResultadoxestudiante(Integer resulxestuidn,
        Integer asigxexamidn_Asignaturaxexamen,
        Integer calixestuidn_Calificacionxestudiante) throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();
        resultadoxestudianteLogic.updateResultadoxestudiante(resulxestuidn,
            asigxexamidn_Asignaturaxexamen, calixestuidn_Calificacionxestudiante);
    }

    public static Resultadoxestudiante getResultadoxestudiante(
        Integer resulxestuidn) throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();
        Resultadoxestudiante resultadoxestudiante = null;

        try {
            resultadoxestudiante = resultadoxestudianteLogic.getResultadoxestudiante(resulxestuidn);
        } catch (Exception e) {
            throw e;
        }

        return resultadoxestudiante;
    }

    public static List<Resultadoxestudiante> findByCriteriaInResultadoxestudiante(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();

        return resultadoxestudianteLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Resultadoxestudiante> findPageResultadoxestudiante(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();

        return resultadoxestudianteLogic.findPageResultadoxestudiante(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberResultadoxestudiante()
        throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();

        return resultadoxestudianteLogic.findTotalNumberResultadoxestudiante();
    }

    public static List<ResultadoxestudianteDTO> getDataResultadoxestudiante()
        throws Exception {
        IResultadoxestudianteLogic resultadoxestudianteLogic = new ResultadoxestudianteLogic();

        return resultadoxestudianteLogic.getDataResultadoxestudiante();
    }

    public static List<Tipoexamen> getTipoexamen() throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();

        return tipoexamenLogic.getTipoexamen();
    }
    
    public static void saveTipoexamen(String tipoexamdescript,
        Integer tipoexamidn) throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();
        tipoexamenLogic.saveTipoexamen(tipoexamdescript, tipoexamidn);
    }

    public static void deleteTipoexamen(Integer tipoexamidn)
        throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();
        tipoexamenLogic.deleteTipoexamen(tipoexamidn);
    }

    public static void updateTipoexamen(String tipoexamdescript,
        Integer tipoexamidn) throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();
        tipoexamenLogic.updateTipoexamen(tipoexamdescript, tipoexamidn);
    }

    public static Tipoexamen getTipoexamen(Integer tipoexamidn)
        throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();
        Tipoexamen tipoexamen = null;

        try {
            tipoexamen = tipoexamenLogic.getTipoexamen(tipoexamidn);
        } catch (Exception e) {
            throw e;
        }

        return tipoexamen;
    }

    public static List<Tipoexamen> findByCriteriaInTipoexamen(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();

        return tipoexamenLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Tipoexamen> findPageTipoexamen(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();

        return tipoexamenLogic.findPageTipoexamen(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoexamen() throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();

        return tipoexamenLogic.findTotalNumberTipoexamen();
    }

    public static List<TipoexamenDTO> getDataTipoexamen()
        throws Exception {
        ITipoexamenLogic tipoexamenLogic = new TipoexamenLogic();

        return tipoexamenLogic.getDataTipoexamen();
    }

    public static List<Usuario> getUsuario() throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.getUsuario();
	}

	public static void saveUsuario(Integer usuaactivon, String usuaclavev,
			String usuacorreov, Date usuafechaactivod, Integer usuaidn,
			String usuaimagent, String usuanombrev, Integer niveidn_Nivel)
			throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		usuarioLogic.saveUsuario(usuaactivon, usuaclavev, usuacorreov,
				usuafechaactivod, usuaidn, usuaimagent, usuanombrev,
				niveidn_Nivel);
	}

	public static void deleteUsuario(Integer usuaidn) throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		usuarioLogic.deleteUsuario(usuaidn);
	}

	public static void updateUsuario(Integer usuaactivon, String usuaclavev,
			String usuacorreov, Date usuafechaactivod, Integer usuaidn,
			String usuaimagent, String usuanombrev, Integer niveidn_Nivel)
			throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		usuarioLogic.updateUsuario(usuaactivon, usuaclavev, usuacorreov,
				usuafechaactivod, usuaidn, usuaimagent, usuanombrev,
				niveidn_Nivel);
	}

	public static Usuario getUsuario(Integer usuaidn) throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		Usuario usuario = null;

		try {
			usuario = usuarioLogic.getUsuario(usuaidn);
		} catch (Exception e) {
			throw e;
		}

		return usuario;
	}

	public static List<Usuario> findByCriteriaInUsuario(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Usuario> findPageUsuario(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.findPageUsuario(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberUsuario() throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.findTotalNumberUsuario();
	}

	public static List<UsuarioDTO> getDataUsuario() throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.getDataUsuario();
    }
    
    public static List<Usuario> findUsuarioLogin(String usuario, String contrasena) throws Exception{
    	
    	IUsuarioLogic usuarioLogic = new UsuarioLogic();
    	return usuarioLogic.findUsuarioLogin(usuario, contrasena);
    }
    
    public static List<Colegio> encontrarColegios(int startingAt, int maxPerPage, String order, String sortField, Map<String, String> filters, String lugaidn) throws Exception{
		IColegioLogic colegioLogic = new ColegioLogic();
		return colegioLogic.encontrarColegios(startingAt, maxPerPage, order, sortField, filters, lugaidn);
    }
    
    public static Long findTotalNumberColegio(Map<String, String> filters, String lugaidn) throws Exception{
    	IColegioLogic colegioLogic = new ColegioLogic();
		return colegioLogic.findTotalNumberColegio(filters, lugaidn);
    }
    
    public static List<ColegioDTO> getColegioDTO() throws Exception {
        IColegioLogic colegioLogic = new ColegioLogic();

        return colegioLogic.getColegioDTO();
    }
    
    public static List<Lugar> obtenerLugarPorCodigo(Long codigoLugar) throws Exception {
        ILugarLogic lugarLogic = new LugarLogic();

        return lugarLogic.obtenerLugarporCodigo(codigoLugar);
    }
    
    public static List<Curso> getGrupo() throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.getGrupo();
    }
    
    public static List<Curso> getSalon(Integer cursidn) throws Exception {
        ICursoLogic cursoLogic = new CursoLogic();

        return cursoLogic.getSalon(cursidn);
    }
    
    
    public static List<Calificacion> findGruposColegios(Long coleidn) throws Exception {
    	 ICalificacionLogic calificacionLogic = new CalificacionLogic();

         return calificacionLogic.findGruposColegios(coleidn);      
    }
    
	public static List<Calificacion> findSalonesGrupo(Integer cal_caliidn)
			throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();

		return calificacionLogic.findSalonesGrupo(cal_caliidn);

	}
	
	public static List<Calificacion> findCalificaciones(Integer cal_caliidn)
			throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();

		return calificacionLogic.findCalificaciones(cal_caliidn);

	}

	public static List<Calificacion> findFechaGruposColegio(Long coleidn)
			throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();

		return calificacionLogic.findFechaGruposColegio(coleidn);

	}

	public static List<VSalones> findNumAlumnSalon(Integer caliidn)
			throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();

		return calificacionLogic.findNumAlumnSalon(caliidn);

	}

	public static List<Calificacionxestudiante> findEstudiantesporCalificacion(Integer caliidn)
			throws Exception {
		ICalificacionxestudianteLogic calificacionxestudianteLogic = new CalificacionxestudianteLogic();

		return calificacionxestudianteLogic
				.findEstudiantesporCalificacion(caliidn);
	}
	
	public static String crearCodigoEstudiante() throws Exception {
		IEstudianteLogic estudianteLogic = new EstudianteLogic();

		return estudianteLogic.crearCodigoEstudiante();
	}
	
	public static List<Examen> getExamenPorExa_examidn(Integer exa_examidn)
			throws Exception {
		IExamenLogic examenLogic = new ExamenLogic();

		return examenLogic.getExamenPorExa_examidn(exa_examidn);
	}
	
	public static Integer numeroDePreguntasPorSesion(Integer examidn)
			throws Exception {
		IAsignaturaxexamenLogic asignaturaxexamen = new AsignaturaxexamenLogic();

		return asignaturaxexamen.numeroDePreguntasPorSesion(examidn);
	}
	
	public static List findEstudiantesxCalificacion(Integer caliidn) throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();

		return calificacionLogic.findEstudiantesxCalificacion(caliidn);

	}

	public static List findNotasxEstudiante(Integer caliidn, Integer estuidn)
			throws Exception {
		ICalificacionLogic calificacionLogic = new CalificacionLogic();

		return calificacionLogic.findNotasxEstudiante(caliidn, estuidn);
	}

}
